﻿namespace VXCompany.SilverlightLogging.ServiceProxy
{
	using System.Runtime.Serialization;
	using System;


	[System.Diagnostics.DebuggerStepThroughAttribute()]
	[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "4.0.0.0")]
	[System.Runtime.Serialization.DataContractAttribute(Name = "LoggingConfigurationMessage", Namespace = "http://schemas.datacontract.org/2004/07/VXCompany.SilverlightLogging.Services.Ser" +
		"viceContracts")]
	public partial class LoggingConfigurationMessage : object, System.ComponentModel.INotifyPropertyChanged
	{

		private string ClientAddressField;

		private bool IsUserAuthenticatedField;

		private ErrorLevel MinLogLevelField;

		private ErrorLevel MinSyncLevelField;

		private SyncBehaviorFlags SyncBehaviorFlagsField;

		private bool SyncWhenStorageUnavailableField;

		private string UserIDField;

		[System.Runtime.Serialization.DataMemberAttribute()]
		public string ClientAddress
		{
			get
			{
				return this.ClientAddressField;
			}
			set
			{
				if ((object.ReferenceEquals(this.ClientAddressField, value) != true))
				{
					this.ClientAddressField = value;
					this.RaisePropertyChanged("ClientAddress");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public bool IsUserAuthenticated
		{
			get
			{
				return this.IsUserAuthenticatedField;
			}
			set
			{
				if ((this.IsUserAuthenticatedField.Equals(value) != true))
				{
					this.IsUserAuthenticatedField = value;
					this.RaisePropertyChanged("IsUserAuthenticated");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public ErrorLevel MinLogLevel
		{
			get
			{
				return this.MinLogLevelField;
			}
			set
			{
				if ((this.MinLogLevelField.Equals(value) != true))
				{
					this.MinLogLevelField = value;
					this.RaisePropertyChanged("MinLogLevel");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public ErrorLevel MinSyncLevel
		{
			get
			{
				return this.MinSyncLevelField;
			}
			set
			{
				if ((this.MinSyncLevelField.Equals(value) != true))
				{
					this.MinSyncLevelField = value;
					this.RaisePropertyChanged("MinSyncLevel");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public SyncBehaviorFlags SyncBehaviorFlags
		{
			get
			{
				return this.SyncBehaviorFlagsField;
			}
			set
			{
				if ((this.SyncBehaviorFlagsField.Equals(value) != true))
				{
					this.SyncBehaviorFlagsField = value;
					this.RaisePropertyChanged("SyncBehaviorFlags");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public bool SyncWhenStorageUnavailable
		{
			get
			{
				return this.SyncWhenStorageUnavailableField;
			}
			set
			{
				if ((this.SyncWhenStorageUnavailableField.Equals(value) != true))
				{
					this.SyncWhenStorageUnavailableField = value;
					this.RaisePropertyChanged("SyncWhenStorageUnavailable");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public string UserID
		{
			get
			{
				return this.UserIDField;
			}
			set
			{
				if ((object.ReferenceEquals(this.UserIDField, value) != true))
				{
					this.UserIDField = value;
					this.RaisePropertyChanged("UserID");
				}
			}
		}

		public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

		protected void RaisePropertyChanged(string propertyName)
		{
			System.ComponentModel.PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
			if ((propertyChanged != null))
			{
				propertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
			}
		}
	}

	[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "4.0.0.0")]
	[System.Runtime.Serialization.DataContractAttribute(Name = "ErrorLevel", Namespace = "http://schemas.datacontract.org/2004/07/VXCompany.SilverlightLogging.Services.Ser" +
		"viceContracts")]
	public enum ErrorLevel : int
	{

		[System.Runtime.Serialization.EnumMemberAttribute()]
		Critical = 3,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		Error = 2,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		Warning = 1,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		Informational = 0,
	}

	[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "4.0.0.0")]
	[System.FlagsAttribute()]
	[System.Runtime.Serialization.DataContractAttribute(Name = "SyncBehaviorFlags", Namespace = "http://schemas.datacontract.org/2004/07/VXCompany.SilverlightLogging.Services.Ser" +
		"viceContracts")]
	public enum SyncBehaviorFlags : int
	{

		[System.Runtime.Serialization.EnumMemberAttribute()]
		PerMinute = 1,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		PerTwoMinutes = 2,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		PerFiveMinutes = 4,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		PerTenMinutes = 16,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		PerFifteenMinutes = 32,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		AppEnd = 64,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		AppCrash = 128,

		[System.Runtime.Serialization.EnumMemberAttribute()]
		AppStart = 256,
	}

	[System.Diagnostics.DebuggerStepThroughAttribute()]
	[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "4.0.0.0")]
	[System.Runtime.Serialization.DataContractAttribute(Name = "ExceptionMessage", Namespace = "http://schemas.datacontract.org/2004/07/VXCompany.SilverlightLogging.Services.Ser" +
		"viceContracts")]
	public partial class ExceptionMessage : object, System.ComponentModel.INotifyPropertyChanged
	{

		private string ClientAddressField;

		private string ClientApplicationField;

		private System.DateTime DateTimeField;

		private System.Guid ExceptionMessageIDField;

		private ExceptionMessage InnerExceptionField;

		private ErrorLevel LevelField;

		private string MessageField;

		private string UserIDField;

		[System.Runtime.Serialization.DataMemberAttribute()]
		public string ClientAddress
		{
			get
			{
				return this.ClientAddressField;
			}
			set
			{
				if ((object.ReferenceEquals(this.ClientAddressField, value) != true))
				{
					this.ClientAddressField = value;
					this.RaisePropertyChanged("ClientAddress");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute(IsRequired = true)]
		public string ClientApplication
		{
			get
			{
				return this.ClientApplicationField;
			}
			set
			{
				if ((object.ReferenceEquals(this.ClientApplicationField, value) != true))
				{
					this.ClientApplicationField = value;
					this.RaisePropertyChanged("ClientApplication");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public System.DateTime DateTime
		{
			get
			{
				return this.DateTimeField;
			}
			set
			{
				if ((this.DateTimeField.Equals(value) != true))
				{
					this.DateTimeField = value;
					this.RaisePropertyChanged("DateTime");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute(IsRequired = true)]
		public System.Guid ExceptionMessageID
		{
			get
			{
				return this.ExceptionMessageIDField;
			}
			set
			{
				if ((this.ExceptionMessageIDField.Equals(value) != true))
				{
					this.ExceptionMessageIDField = value;
					this.RaisePropertyChanged("ExceptionMessageID");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public ExceptionMessage InnerException
		{
			get
			{
				return this.InnerExceptionField;
			}
			set
			{
				if ((object.ReferenceEquals(this.InnerExceptionField, value) != true))
				{
					this.InnerExceptionField = value;
					this.RaisePropertyChanged("InnerException");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public ErrorLevel Level
		{
			get
			{
				return this.LevelField;
			}
			set
			{
				if ((this.LevelField.Equals(value) != true))
				{
					this.LevelField = value;
					this.RaisePropertyChanged("Level");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public string Message
		{
			get
			{
				return this.MessageField;
			}
			set
			{
				if ((object.ReferenceEquals(this.MessageField, value) != true))
				{
					this.MessageField = value;
					this.RaisePropertyChanged("Message");
				}
			}
		}

		[System.Runtime.Serialization.DataMemberAttribute()]
		public string UserID
		{
			get
			{
				return this.UserIDField;
			}
			set
			{
				if ((object.ReferenceEquals(this.UserIDField, value) != true))
				{
					this.UserIDField = value;
					this.RaisePropertyChanged("UserID");
				}
			}
		}

		public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

		protected void RaisePropertyChanged(string propertyName)
		{
			System.ComponentModel.PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
			if ((propertyChanged != null))
			{
				propertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
			}
		}
	}

	[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
	[System.ServiceModel.ServiceContractAttribute(Namespace = "VXCompany.VXCompany.SilverlightLogging.Services", ConfigurationName = "LoggingService.ILoggingService")]
	public interface ILoggingService
	{

		[System.ServiceModel.OperationContractAttribute(AsyncPattern = true, Action = "VXCompany.VXCompany.SilverlightLogging.Services/ILoggingService/GetClientConfig", ReplyAction = "VXCompany.VXCompany.SilverlightLogging.Services/ILoggingService/GetClientConfigRe" +
			"sponse")]
		System.IAsyncResult BeginGetClientConfig(System.AsyncCallback callback, object asyncState);

		LoggingConfigurationMessage EndGetClientConfig(System.IAsyncResult result);

		[System.ServiceModel.OperationContractAttribute(IsOneWay = true, AsyncPattern = true, Action = "VXCompany.VXCompany.SilverlightLogging.Services/ILoggingService/LogExceptionBatch" +
			"")]
		System.IAsyncResult BeginLogExceptionBatch(System.Collections.ObjectModel.ObservableCollection<ExceptionMessage> messages, System.AsyncCallback callback, object asyncState);

		void EndLogExceptionBatch(System.IAsyncResult result);
	}

	[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
	public interface ILoggingServiceChannel : ILoggingService, System.ServiceModel.IClientChannel
	{
	}

	[System.Diagnostics.DebuggerStepThroughAttribute()]
	[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
	public partial class GetClientConfigCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs
	{

		private object[] results;

		public GetClientConfigCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) :
			base(exception, cancelled, userState)
		{
			this.results = results;
		}

		public LoggingConfigurationMessage Result
		{
			get
			{
				base.RaiseExceptionIfNecessary();
				return ((LoggingConfigurationMessage)(this.results[0]));
			}
		}
	}

	[System.Diagnostics.DebuggerStepThroughAttribute()]
	[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
	public partial class LoggingServiceClient : System.ServiceModel.ClientBase<ILoggingService>, ILoggingService
	{

		private BeginOperationDelegate onBeginGetClientConfigDelegate;

		private EndOperationDelegate onEndGetClientConfigDelegate;

		private System.Threading.SendOrPostCallback onGetClientConfigCompletedDelegate;

		private BeginOperationDelegate onBeginLogExceptionBatchDelegate;

		private EndOperationDelegate onEndLogExceptionBatchDelegate;

		private System.Threading.SendOrPostCallback onLogExceptionBatchCompletedDelegate;

		private BeginOperationDelegate onBeginOpenDelegate;

		private EndOperationDelegate onEndOpenDelegate;

		private System.Threading.SendOrPostCallback onOpenCompletedDelegate;

		private BeginOperationDelegate onBeginCloseDelegate;

		private EndOperationDelegate onEndCloseDelegate;

		private System.Threading.SendOrPostCallback onCloseCompletedDelegate;

		public LoggingServiceClient()
		{
		}

		public LoggingServiceClient(string endpointConfigurationName) :
			base(endpointConfigurationName)
		{
		}

		public LoggingServiceClient(string endpointConfigurationName, string remoteAddress) :
			base(endpointConfigurationName, remoteAddress)
		{
		}

		public LoggingServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) :
			base(endpointConfigurationName, remoteAddress)
		{
		}

		public LoggingServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) :
			base(binding, remoteAddress)
		{
		}

		public System.Net.CookieContainer CookieContainer
		{
			get
			{
				System.ServiceModel.Channels.IHttpCookieContainerManager httpCookieContainerManager = this.InnerChannel.GetProperty<System.ServiceModel.Channels.IHttpCookieContainerManager>();
				if ((httpCookieContainerManager != null))
				{
					return httpCookieContainerManager.CookieContainer;
				}
				else
				{
					return null;
				}
			}
			set
			{
				System.ServiceModel.Channels.IHttpCookieContainerManager httpCookieContainerManager = this.InnerChannel.GetProperty<System.ServiceModel.Channels.IHttpCookieContainerManager>();
				if ((httpCookieContainerManager != null))
				{
					httpCookieContainerManager.CookieContainer = value;
				}
				else
				{
					throw new System.InvalidOperationException("Unable to set the CookieContainer. Please make sure the binding contains an HttpC" +
							"ookieContainerBindingElement.");
				}
			}
		}

		public event System.EventHandler<GetClientConfigCompletedEventArgs> GetClientConfigCompleted;

		public event System.EventHandler<System.ComponentModel.AsyncCompletedEventArgs> LogExceptionBatchCompleted;

		public event System.EventHandler<System.ComponentModel.AsyncCompletedEventArgs> OpenCompleted;

		public event System.EventHandler<System.ComponentModel.AsyncCompletedEventArgs> CloseCompleted;

		[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
		System.IAsyncResult ILoggingService.BeginGetClientConfig(System.AsyncCallback callback, object asyncState)
		{
			return base.Channel.BeginGetClientConfig(callback, asyncState);
		}

		[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
		LoggingConfigurationMessage ILoggingService.EndGetClientConfig(System.IAsyncResult result)
		{
			return base.Channel.EndGetClientConfig(result);
		}

		private System.IAsyncResult OnBeginGetClientConfig(object[] inValues, System.AsyncCallback callback, object asyncState)
		{
			return ((ILoggingService)(this)).BeginGetClientConfig(callback, asyncState);
		}

		private object[] OnEndGetClientConfig(System.IAsyncResult result)
		{
			LoggingConfigurationMessage retVal = ((ILoggingService)(this)).EndGetClientConfig(result);
			return new object[] {
                    retVal};
		}

		private void OnGetClientConfigCompleted(object state)
		{
			if ((this.GetClientConfigCompleted != null))
			{
				InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
				this.GetClientConfigCompleted(this, new GetClientConfigCompletedEventArgs(e.Results, e.Error, e.Cancelled, e.UserState));
			}
		}

		public void GetClientConfigAsync()
		{
			this.GetClientConfigAsync(null);
		}

		public void GetClientConfigAsync(object userState)
		{
			if ((this.onBeginGetClientConfigDelegate == null))
			{
				this.onBeginGetClientConfigDelegate = new BeginOperationDelegate(this.OnBeginGetClientConfig);
			}
			if ((this.onEndGetClientConfigDelegate == null))
			{
				this.onEndGetClientConfigDelegate = new EndOperationDelegate(this.OnEndGetClientConfig);
			}
			if ((this.onGetClientConfigCompletedDelegate == null))
			{
				this.onGetClientConfigCompletedDelegate = new System.Threading.SendOrPostCallback(this.OnGetClientConfigCompleted);
			}
			base.InvokeAsync(this.onBeginGetClientConfigDelegate, null, this.onEndGetClientConfigDelegate, this.onGetClientConfigCompletedDelegate, userState);
		}

		[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
		System.IAsyncResult ILoggingService.BeginLogExceptionBatch(System.Collections.ObjectModel.ObservableCollection<ExceptionMessage> messages, System.AsyncCallback callback, object asyncState)
		{
			return base.Channel.BeginLogExceptionBatch(messages, callback, asyncState);
		}

		[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
		void ILoggingService.EndLogExceptionBatch(System.IAsyncResult result)
		{
			base.Channel.EndLogExceptionBatch(result);
		}

		private System.IAsyncResult OnBeginLogExceptionBatch(object[] inValues, System.AsyncCallback callback, object asyncState)
		{
			System.Collections.ObjectModel.ObservableCollection<ExceptionMessage> messages = ((System.Collections.ObjectModel.ObservableCollection<ExceptionMessage>)(inValues[0]));
			return ((ILoggingService)(this)).BeginLogExceptionBatch(messages, callback, asyncState);
		}

		private object[] OnEndLogExceptionBatch(System.IAsyncResult result)
		{
			((ILoggingService)(this)).EndLogExceptionBatch(result);
			return null;
		}

		private void OnLogExceptionBatchCompleted(object state)
		{
			if ((this.LogExceptionBatchCompleted != null))
			{
				InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
				this.LogExceptionBatchCompleted(this, new System.ComponentModel.AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
			}
		}

		public void LogExceptionBatchAsync(System.Collections.ObjectModel.ObservableCollection<ExceptionMessage> messages)
		{
			this.LogExceptionBatchAsync(messages, null);
		}

		public void LogExceptionBatchAsync(System.Collections.ObjectModel.ObservableCollection<ExceptionMessage> messages, object userState)
		{
			if ((this.onBeginLogExceptionBatchDelegate == null))
			{
				this.onBeginLogExceptionBatchDelegate = new BeginOperationDelegate(this.OnBeginLogExceptionBatch);
			}
			if ((this.onEndLogExceptionBatchDelegate == null))
			{
				this.onEndLogExceptionBatchDelegate = new EndOperationDelegate(this.OnEndLogExceptionBatch);
			}
			if ((this.onLogExceptionBatchCompletedDelegate == null))
			{
				this.onLogExceptionBatchCompletedDelegate = new System.Threading.SendOrPostCallback(this.OnLogExceptionBatchCompleted);
			}
			base.InvokeAsync(this.onBeginLogExceptionBatchDelegate, new object[] {
                        messages}, this.onEndLogExceptionBatchDelegate, this.onLogExceptionBatchCompletedDelegate, userState);
		}

		private System.IAsyncResult OnBeginOpen(object[] inValues, System.AsyncCallback callback, object asyncState)
		{
			return ((System.ServiceModel.ICommunicationObject)(this)).BeginOpen(callback, asyncState);
		}

		private object[] OnEndOpen(System.IAsyncResult result)
		{
			((System.ServiceModel.ICommunicationObject)(this)).EndOpen(result);
			return null;
		}

		private void OnOpenCompleted(object state)
		{
			if ((this.OpenCompleted != null))
			{
				InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
				this.OpenCompleted(this, new System.ComponentModel.AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
			}
		}

		public void OpenAsync()
		{
			this.OpenAsync(null);
		}

		public void OpenAsync(object userState)
		{
			if ((this.onBeginOpenDelegate == null))
			{
				this.onBeginOpenDelegate = new BeginOperationDelegate(this.OnBeginOpen);
			}
			if ((this.onEndOpenDelegate == null))
			{
				this.onEndOpenDelegate = new EndOperationDelegate(this.OnEndOpen);
			}
			if ((this.onOpenCompletedDelegate == null))
			{
				this.onOpenCompletedDelegate = new System.Threading.SendOrPostCallback(this.OnOpenCompleted);
			}
			base.InvokeAsync(this.onBeginOpenDelegate, null, this.onEndOpenDelegate, this.onOpenCompletedDelegate, userState);
		}

		private System.IAsyncResult OnBeginClose(object[] inValues, System.AsyncCallback callback, object asyncState)
		{
			return ((System.ServiceModel.ICommunicationObject)(this)).BeginClose(callback, asyncState);
		}

		private object[] OnEndClose(System.IAsyncResult result)
		{
			((System.ServiceModel.ICommunicationObject)(this)).EndClose(result);
			return null;
		}

		private void OnCloseCompleted(object state)
		{
			if ((this.CloseCompleted != null))
			{
				InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
				this.CloseCompleted(this, new System.ComponentModel.AsyncCompletedEventArgs(e.Error, e.Cancelled, e.UserState));
			}
		}

		public void CloseAsync()
		{
			this.CloseAsync(null);
		}

		public void CloseAsync(object userState)
		{
			if ((this.onBeginCloseDelegate == null))
			{
				this.onBeginCloseDelegate = new BeginOperationDelegate(this.OnBeginClose);
			}
			if ((this.onEndCloseDelegate == null))
			{
				this.onEndCloseDelegate = new EndOperationDelegate(this.OnEndClose);
			}
			if ((this.onCloseCompletedDelegate == null))
			{
				this.onCloseCompletedDelegate = new System.Threading.SendOrPostCallback(this.OnCloseCompleted);
			}
			base.InvokeAsync(this.onBeginCloseDelegate, null, this.onEndCloseDelegate, this.onCloseCompletedDelegate, userState);
		}

		protected override ILoggingService CreateChannel()
		{
			return new LoggingServiceClientChannel(this);
		}

		private class LoggingServiceClientChannel : ChannelBase<ILoggingService>, ILoggingService
		{

			public LoggingServiceClientChannel(System.ServiceModel.ClientBase<ILoggingService> client) :
				base(client)
			{
			}

			public System.IAsyncResult BeginGetClientConfig(System.AsyncCallback callback, object asyncState)
			{
				object[] _args = new object[0];
				System.IAsyncResult _result = base.BeginInvoke("GetClientConfig", _args, callback, asyncState);
				return _result;
			}

			public LoggingConfigurationMessage EndGetClientConfig(System.IAsyncResult result)
			{
				object[] _args = new object[0];
				LoggingConfigurationMessage _result = ((LoggingConfigurationMessage)(base.EndInvoke("GetClientConfig", _args, result)));
				return _result;
			}

			public System.IAsyncResult BeginLogExceptionBatch(System.Collections.ObjectModel.ObservableCollection<ExceptionMessage> messages, System.AsyncCallback callback, object asyncState)
			{
				object[] _args = new object[1];
				_args[0] = messages;
				System.IAsyncResult _result = base.BeginInvoke("LogExceptionBatch", _args, callback, asyncState);
				return _result;
			}

			public void EndLogExceptionBatch(System.IAsyncResult result)
			{
				object[] _args = new object[0];
				base.EndInvoke("LogExceptionBatch", _args, result);
			}
		}
	}
}

